const amap = require("../../util/amap");
// 获取当前时间
var currentTime = new Date();

// 判断上午或下午
var meridiem = currentTime.getHours() < 12 ? '上午' : '下午';

// 将当前时间格式化为你想要的格式，比如 yyyy-MM-dd HH:mm:ss
var year = currentTime.getFullYear();
var month = currentTime.getMonth() + 1;
var date = currentTime.getDate();
var hours = currentTime.getHours();
var minutes = currentTime.getMinutes();
var seconds = currentTime.getSeconds();

// 格式化时间，确保月、日、时、分、秒始终为两位数
if (month < 10) {
    month = '0' + month;
}
if (date < 10) {
    date = '0' + date;
}
if (hours < 10) {
    hours = '0' + hours;
}
if (minutes < 10) {
    minutes = '0' + minutes;
}
if (seconds < 10) {
    seconds = '0' + seconds;
}

// 将时间拼接成字符串，形如 "2024-03-11 14:30:00"
var time = year + '-' + month + '-' + date + ' ' + hours + ':' + minutes + ':' + seconds;




Page({
  data: {
    user: '',
    result: '',
    result2: [],
    url_token: '',
    text: '',
    nearbyList: [], // 存储搜索到的景点信息
    markers: [], // 地图标记点
    polylines: [], // 地图路线
    latitude: 30.67, // 成都市中心点
    longitude: 104.06, // 成都市中心点
    feedback: '', // 低分原因
    time:time,
    meridiem: meridiem,
    currentSwiper: 0, // 当前轮播图索引
    showMap: false, // 控制地图显示状态
  },
  onShow() {
    this.setData({ user: wx.getStorageSync('user') || '' });
  },
  onLoad: function(options) {

    this.getRecommendUrl();
    const result = decodeURIComponent(options.result); // 解码 result 参数
    const formattedResult = this.formatResult(result); // 格式化 result
    this.setData({
      result: formattedResult // 设置到页面数据中
    });
  },

  getRecommendUrl() {
    const db = wx.cloud.database();
    const recommendCollection = db.collection('zyzl_recommend');
    recommendCollection.get().then(res => {
      if (res.data.length > 0) {
        const recommendInfo = res.data[0];
        const url_token = recommendInfo.url_token; // 获取recommend字段中的url_token值
        const text = recommendInfo.text;
        this.setData({ url_token }); // 设置到页面数据中
        this.setData({ text });
        this.getToken();
      } else {
        console.error('未找到数据');
      }
    }).catch(err => {
      console.error('获取数据失败', err);
    });
  },

  getToken() {
    wx.showToast({
      title: '正在处理中๑ᵒᯅᵒ๑',
      icon: 'loading',
      duration: 6000
    });
    wx.request({
      url: this.data.url_token,
      method: "POST",
      header: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      success: res => {
        const access_token = res.data.access_token;
        console.log("access_token"+access_token);
        const url_chat = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions_pro?access_token=" + access_token;
        
        const payload = {
          messages: [{
            role: "user",
            content: "提取下方推荐信息的所有景点名称并严格按照数组格式返回给我(格式参考： [\"天坛公园\", \"故宫\", \"颐和园\", \"北海公园\", \"圆明园\"]，提取到的景点名称必须放在[]里面),并且不要有加粗字体和Markdown格式的字体出现，需要提取景点名的推荐信息如下：" + this.data.result
          }]
        };

        wx.request({
          url: url_chat,
          method: "POST",
          data: payload,
          header: { 'Content-Type': 'application/json' },
          success: res => {
            console.log('请求成功，返回数据:', res);  // 打印完整的响应数据
            if (res.data && res.data.result) {
              this.setData({
                result2: res.data.result
              });
              wx.showToast({
                title: '成功',
                icon: 'success'
              });
              this.searchNearby(); // 调用搜索附近景点的方法
            } else {
              console.error('返回数据没有 result 字段');
            }
          },
          fail: err => {
            console.error('请求失败', err);  // 打印请求失败的错误
          }
        });
        
      },
    });
  },

  showFeedbackDialog() {
    console.log("显示反馈对话框");
    const user = wx.getStorageSync('user'); // 从 Storage 中获取用户信息
  
    if (!user) {
      wx.showModal({
        title: '提示',
        content: '请先登录',
        showCancel: false,
        success(res) {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/my/login/login'
            });
          }
        }
      });
      return;
    }

    wx.showModal({
      title: '重新推荐',
      editable: true,
      placeholderText: '请输入不满意的原因',
      showCancel: true,
      success: (modalRes) => {
        if (modalRes.confirm && modalRes.content) {
          this.setData({ 
            feedback: modalRes.content,
            loadModal: true // 显示加载框
          });
          this.getToken2();
        } else if (modalRes.confirm) {
          wx.showToast({
            title: '请填写原因',
            icon: 'none'
          });
        }
      }
    });
  },
  
  getToken2() {
    // 显示加载框
    this.setData({
      loadModal: true
    });

    wx.request({
      url: this.data.url_token,
      method: "POST",
      header: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      success: res => {
        const access_token = res.data.access_token;
        const url_chat = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions_pro?access_token=" + access_token;
        
        // 构建二次推荐的请求
        const payload = {
          messages: [{
            role: "user",
            content: "这个推荐路线用户不满意：【" + this.data.result + "】，不满意的原因是：【" + this.data.feedback + "】，请优化这个结果并重新生成推荐结果" + "，格式要求参考：【" + this.data.text + "】"
          }]
        };

        // 获取新的推荐结果
        wx.request({
          url: url_chat,
          method: "POST",
          data: payload,
          header: { 'Content-Type': 'application/json' },
          success: res => {
            console.log("res是",res)
            if (res.data && res.data.result) {
              // 保存新的推荐结果
              const newResult = res.data.result;
              
              // 获取新推荐中的景点名称
              wx.request({
                url: url_chat,
                method: "POST",
                data: {
                  messages: [{
                    role: "user",
                    content: "提取下方推荐信息的所有景点名称并严格按照数组格式返回给我(格式参考： [\"天坛公园\", \"故宫\", \"颐和园\", \"北海公园\", \"圆明园\"]，提取到的景点名称必须放在[]里面)，需要提取景点名的推荐信息如下：" + newResult
                  }]
                },
                header: { 'Content-Type': 'application/json' },
                success: res => {
                  if (res.data && res.data.result) {
                    // 更新页面数据
                    this.setData({
                      result: this.formatResult(newResult),
                      result2: res.data.result,
                      loadModal: false
                    });

                    // 保存推荐记录
                    this.saveRecommendOrder({
                      result: newResult,
                      timestamp: new Date()
                    });

                    // 重新搜索景点信息
                    this.searchNearby();

                    wx.showToast({
                      title: '推荐成功',
                      icon: 'success'
                    });
                  } else {
                    this.handleError('解析景点失败');
                  }
                },
                fail: err => {
                  this.handleError('解析景点请求失败');
                }
              });
            } else {
              this.handleError('获取推荐失败');
            }
          },
          fail: err => {
            this.handleError('推荐请求失败');
          }
        });
      },
      fail: err => {
        this.handleError('获取token失败');
      }
    });
  },
  
  getClass: function(index) {
    var classArray = ['bg-green shadow-blur', 'bg-grey shadow-blur', 'bg-blue content', 'bg-cyan content']; // 定义不同的 class 数组
    return classArray[index % classArray.length]; // 返回对应索引的 class
  },
  saveRecommendOrder(result) {
    const db = wx.cloud.database();
    const orderCollection = db.collection('zyzl_recommandorder');
    const orderData = {
      user: this.data.user,
      result: result,
      timestamp: this.data.timestamp
    };
    orderCollection.add({
      data: orderData,
      success: res => {
        console.log('存储成功', res);
      },
      fail: err => {
        console.error('存储失败', err);
      }
    });
  },
  searchNearby() {
    const db = wx.cloud.database();
    const _ = db.command;
    const nearbyList = [];

    // 提取 ``` 之间的内容作为景点名称数组
    const regex = /\[([\s\S]+)\]/; // 修改正则表达式
    console.log(this.data);
    const matchResult = this.data.result2.match(regex);
    if (matchResult) {
      const result2Array = matchResult[1].split(',').map(item => item.replace(/"/g, '').trim()); // 提取并处理数组项
      // 遍历 result2Array 中的每个景点名称进行搜索
      result2Array.forEach(keyword => {
        // 根据关键词搜索附近景点信息
        db.collection('zyzl_nearbylist').where({
          name: _.eq(keyword) // 不需要再去除空格
        }).get().then(res => {
          if (res.data.length > 0) {
            nearbyList.push(res.data[0]); // 将搜索到的景点信息添加到 nearbyList 中

            // 获取最新的一条数据并存入数据库
            db.collection('zyzl_recommandorder').where({
              user: _.eq(this.data.user) // 匹配用户
            }).orderBy('timestamp', 'desc').limit(1).get().then(recommandRes => {
              if (recommandRes.data.length > 0) {
                const latestData = recommandRes.data[0]; // 获取最新的一条数据
                // 更新数据库中的最新数据的 nearbyList 字段
                db.collection('zyzl_recommandorder').doc(latestData._id).update({
                  data: {
                    nearbyList: nearbyList
                  },
                  success: function(updateRes) {
                    console.log('成功更新数据库中最新数据的 nearbyList 字段', updateRes);
                  },
                  fail: function(error) {
                    console.error('更新数据库中最新数据的 nearbyList 字段失败', error);
                  }
                });
              }
              // 更新页面数据
              this.setData({ nearbyList });
              // console.log('景点数据:', nearbyList);

              // 请求成功后调用initMap方法
              this.initMap();
            }).catch(err => {
              console.error('获取最新数据失败', err);
            });
          } 
        }).catch(err => {
          console.error('搜索景点信息失败', err);
        });
      });
    } else {
      console.error('未找到匹配的结果');
    }
  },

  initMap() {
    // 获取附近景点信息
    const nearbyList = this.data.nearbyList;
    console.log("data是"+this.data);
    // 初始化地图标记点
    const markers = nearbyList.map((item, index) => {
      return {
        iconPath: "../map/images/Redmaker.png",
        id: index,
        latitude: item.latitude2,
        longitude: item.longitude2,
        width: 20,
        height: 20
      };
    });
console.log("调试1"+markers);
    // 设置地图标记点
    this.setData({ markers });
    // 绘制地图路线
    this.drawRoute();
  },

  drawRoute() {
    const nearbyList = this.data.nearbyList;
    const polylines = []; // 存储所有路线
  
    const promises = [];
  
    for (let i = 0; i < nearbyList.length - 1; i++) {
      const origin = `${nearbyList[i].longitude2},${nearbyList[i].latitude2}`;
      const destination = `${nearbyList[i + 1].longitude2},${nearbyList[i + 1].latitude2}`;
  
      const promise = amap.getRoute(origin, destination, "getDrivingRoute")
        .then(route => {
          const points = route.paths[0].steps.reduce((acc, step) => {
            const polyline = step.polyline.split(';');
            return acc.concat(polyline.map(point => {
              const [longitude, latitude] = point.split(',');
              return { latitude: parseFloat(latitude), longitude: parseFloat(longitude) };
            }));
          }, []);
  
          polylines.push({
            points,
            color: "#0091ff",
            width: 6
          });
        })
        .catch(error => {
          console.error('绘制路线失败', error);
        });
  
      promises.push(promise);
    }
  
    Promise.all(promises)
      .then(() => {
        this.setData({
          polylines: polylines
        });
      })
      .catch(error => {
        console.error('Promise.all 失败', error);
      });
  },
  

  // onUnload() {
  //   wx.showActionSheet({
  //     itemList: ['5分 ★★★★★', '4分 ★★★★☆', '3分 ★★★☆☆', '2分 ★★☆☆☆', '1分 ★☆☆☆☆'],
  //     success: (res) => {
  //       const score = 5 - res.tapIndex; // 将用户选择的评分转为 1-5 的数字
  //       if (score === 1 || score === 2) {
  //         // 如果是1分或2分，弹出输入框让用户填写低分原因
  //         wx.showModal({
  //           title: '低分原因（填写后可以二次推荐更合适的方案哦）',
  //           editable: true, //显示输入框
  //           placeholderText: '请输入不满意的原因', //显示输入框提示信息
  //           showCancel: true, // 显示取消按钮
  //           success: (modalRes) => {
  //             if (modalRes.confirm) {
  //               // 用户点击确定时，modalRes.content 是用户填写的原因
  //               this.setData({ feedback: modalRes.content });
  //               // 提交评分和低分原因
  //               this.submitScore(score);
  
  //             } else {
  //               // 用户点击取消时，不执行任何操作
  //             }
  //           }
  //         });
  //       } else {
  //         // 其他评分直接提交评分
  //         this.submitScore(score);
  //       }
  //     }
  //   });
  // },
  
  
  
  submitScore(score) {
    const db = wx.cloud.database();
    const _ = db.command;

    // 查询最新一条数据的_id
    db.collection('zyzl_recommandorder')
      .orderBy('timestamp', 'desc')
      .limit(1)
      .get()
      .then(res => {
        if (res.data.length > 0) {
          const latestId = res.data[0]._id;
          // 更新最新一条数据的评分字段和低分原因
          db.collection('zyzl_recommandorder')
            .doc(latestId)
            .update({
              data: {
                score: score,
                feedback: this.data.feedback // 将填写的低分原因一同提交
              }
            })
            .then(() => {
              wx.showToast({
                title: '反馈成功',
                icon: 'success'
              });
              if (score === 1 || score === 2) {
                this.getToken2();
              }
            })
            .catch((err) => {
              wx.showToast({
                title: '反馈失败',
                icon: 'success'
              });
            });
        } else {
          console.error('未找到最新的推荐订单数据');
        }
      })
      .catch((err) => {
        console.error('查询最新数据失败', err);
      });
  },

  formatResult: function(result) {
    if (!result) {
      return '';
    }
    return result.replace(/\n/g, '<br>');
  },

  // 轮播图切换事件
  swiperChange(e) {
    this.setData({
      currentSwiper: e.detail.current
    });
  },

  // 卡片切换事件
  cardChange(e) {
    this.setData({
      currentSwiper: e.detail.current
    });
  },

  // 预览图片
  previewImage(e) {
    const current = e.currentTarget.dataset.url;
    const urls = this.data.nearbyList.map(item => item.img1);
    wx.previewImage({
      current,
      urls
    });
  },

  // 显示地图
  showRouteImage() {
    console.log("显示地图");
    this.setData({
      showMap: true
    });
  },

  // 隐藏地图
  hideRouteImage() {
    console.log("隐藏地图");
    this.setData({
      showMap: false
    });
  },

  // 导航到地图
  goToMap(e) {
    const index = e.currentTarget.dataset.index;
    const item = this.data.nearbyList[index];
    
    wx.navigateTo({
      url: `/pages/map/routes/routes?latitude=${this.data.latitude}&longitude=${this.data.longitude}&latitude2=${item.latitude2}&longitude2=${item.longitude2}&city=${item.city}&name=${item.name}&desc=${item.desc}`
    });
  },

  // 统一处理错误
  handleError(message) {
    console.error(message);
    this.setData({
      loadModal: false
    });
    wx.showToast({
      title: message,
      icon: 'none'
    });
  }
});
